Matplotlibi animatsioon: Dünaamiliste graafikute loomine

Andmeanalüüs on andmeteaduse ja teadusarvutuste oluline osa. Staatilised graafikud pakuvad ülevaadet andmetest, kuid mõnikord parandab aja jooksul andmete muutumise või dünaamiliste suhete visualiseerimine mõistmist. Matplotlib, laialt kasutatav Pythoni visualiseerimisraamatukogu, pakub tugevaid animatsioonivõimalusi. See blogipostitus sukeldub Matplotlibi animatsioonimaailma, pakkudes põhjalikku juhendit dünaamiliste graafikute loomiseks, mis äratavad teie andmed ellu.

Miks oma graafikuid animeerida?

Animatsioon pakub staatiliste graafikute ees mitmeid eeliseid:

• Ajatelgede trendide visualiseerimine: Kuidas andmed aja jooksul muutuvad, muutub intuitiivseks. Mõelge aktsiahindade kõikumisele, ilmastikutingimuste muutumisele või haiguse levikule.
• Keeruliste suhete mõistmise parandamine: Animatsioon võib illustreerida põhjus-tagajärg seoseid või sõltuvusi, mida on staatilisest pildist raske haarata.
• Kaasahaaravad ettekanded: Dünaamilised graafikud on köitvamad kui staatilised, muutes esitlused tõhusamaks ja meeldejäävamaks. Kujutage ette simulatsioonitulemuste esitamist areneva visualiseeringuga.
• Reaalajas andmete visualiseerimine: Matplotlibi animatsiooni saab kasutada reaalajas andmevoogude, näiteks andurite näitude või turuandmete kuvamiseks.

Matplotlibi animatsiooni põhimõisted

Matplotlibi animatsioon tugineb moodulile matplotlib.animation. Peamine idee on pidevalt uuendada graafiku sisu silmuses, luues liikumise illusiooni. Selle protsessi hõlbustavad kaks peamist klassi:

• FuncAnimation: See on kõige mitmekülgsem klass. See kutsub korduvalt kasutaja määratletud funktsiooni, et värskendada graafiku sisu animatsiooni iga kaadri jaoks.
• ArtistAnimation: See klass võtab sisendiks Artist-objektide (nt jooned, kujundid) jada ja kuvab neid järjestikku, luues animatsiooni. See sobib, kui teil on juba eelnevalt määratletud kaadrite komplekt.

Peamised komponendid

• Figure ja Axes: Nagu staatiliste graafikute puhul, vajate joonistamiseks Figure-objekti ja ühte või enamat Axes-objekti.
• Initsialiseerimisfunktsioon (init): Seda valikulist funktsiooni kutsutakse animatsiooni alguses üks kord, et luua algsed graafikuelemendid (nt telgede piiride seadmine, tühjade joonte loomine).
• Animatsioonifunktsioon (func): See funktsioon on animatsiooni süda. Seda kutsutakse korduvalt iga kaadri jaoks ja see värskendab graafiku sisu praeguse kaadri numbri või ajahüpete põhjal. See funktsioon saab argumendina kaadri numbri.
• Kaadrite generaator: See määrab animatsioonis kasutatavate kaadrite numbrite või andmepunktide jada. See võib olla lihtne numbrite vahemik (nt range(100)) või keerukam iteraator, mis annab andmeväärtusi.
• interval: See parameeter määrab kaadrite vahelise viivituse (millisekundites). Väiksem intervall annab kiirema animatsiooni.
• blit: blit=True seadmine optimeerib animatsiooni, joonistades uuesti ainult need osa graafikust, mis on muutunud. See parandab oluliselt jõudlust, eriti keerukate graafikute puhul.

Esimese animatsiooni loomine funktsiooniga FuncAnimation

Alustame lihtsa näitega: siinuslaine animeerimisega.

            import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

fig, ax = plt.subplots()
x = np.linspace(0, 2*np.pi, 100)
line, = ax.plot(x, np.sin(x))

def init():
    line.set_ydata([np.nan] * len(x))
    return line,

def animate(i):
    line.set_ydata(np.sin(x + i/10.0))
    return line,

ani = animation.FuncAnimation(fig, animate, init_func=init, frames=200, interval=20, blit=True)

plt.show()

            

              
                Copy
              
            
          

Selgitus:

1. Teekide importimine: Impordime vajalikud teegid: numpy numbriliste operatsioonide jaoks, matplotlib.pyplot graafikute jaoks ja matplotlib.animation animatsiooni jaoks.
2. Figure ja Axes loomine: Loome Figure ja Axes objekti, kasutades plt.subplots().
3. Andmete genereerimine: Loome massiivi x, mis esindab meie siinuslaine x-väärtusi, kasutades np.linspace().
4. Joonobjekti loomine: Loome joonobjekti, kasutades ax.plot(), mida värskendatakse animatsiooni igas kaadris. Komaga pärast `line` on oluline; see pakkib lahti `ax.plot` poolt tagastatud tüübi.
5. Initsialiseerimisfunktsioon (init): See funktsioon seab joone algseks y-andmestikuks NaN (Not a Number), muutes selle animatsiooni alguses tõhusalt nähtamatuks.
6. Animatsioonifunktsioon (animate): See funktsioon värskendab joone y-andmestikku igas kaadris. See arvutab x + i/10.0 siinust, kus i on kaadri number. See nihutab siinuslaine horisontaalselt, luues animatsiooniefekti.
7. FuncAnimation objekti loomine: Loome FuncAnimation objekti, edastades sellele Figure, animatsioonifunktsiooni (animate), initsialiseerimisfunktsiooni (init_func=init), kaadrite arvu (frames=200), kaadritevahelise intervalli (interval=20 millisekundit) ja optimeerimiseks blit=True.
8. Animatsiooni kuvamine: Lõpuks kasutame animatsiooni kuvamiseks plt.show().

Animatsiooni kohandamine

Matplotlib pakub laialdasi võimalusi oma animatsioonide kohandamiseks:

Värvide, joonestiilide ja markerite muutmine

Saate muuta oma graafikuelementide välimust animatsioonifunktsioonis samamoodi, nagu teeksite staatilise graafiku puhul. Näiteks:

            def animate(i):
    line.set_ydata(np.sin(x + i/10.0))
    line.set_color(plt.cm.viridis(i/200.0))  # Muuda värvi kaadri numbri järgi
    return line,

            

              
                Copy
              
            
          

See kood muudab siinuslaine värvi kaadri numbri põhjal, kasutades viridis värvikaarti.

Teksti ja annotatsioonide lisamine

Saate oma animatsioonile lisada teksti ja annotatsioone, et pakkuda täiendavat teavet. Värskendage teksti sisu animatsioonifunktsioonis.

            text = ax.text(0.05, 0.95, '', transform=ax.transAxes, ha='left', va='top')

def animate(i):
    line.set_ydata(np.sin(x + i/10.0))
    text.set_text('Kaader: %d' % i)
    return line, text

            

              
                Copy
              
            
          

See kood lisab tekstisildi, mis kuvab praeguse kaadri numbri.

Telgede piiride muutmine

Kui teie andmete vahemik animatsiooni ajal muutub, peate võib-olla telgede piire dünaamiliselt reguleerima.

            def animate(i):
    y = np.sin(x + i/10.0)
    line.set_ydata(y)
    ax.set_ylim(min(y), max(y))
    return line,

            

              
                Copy
              
            
          

See kood reguleerib y-telje piire, et need sobiksid siinuslaine miinimum- ja maksimumväärtustega igas kaadris.

ArtistAnimation kasutamine

ArtistAnimation klass on kasulik, kui teil on eelnevalt määratletud kaadrite komplekt, mida kuvada.

            import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

fig, ax = plt.subplots()

frames = []
for i in range(50):
    x = np.linspace(0, 2*np.pi, 100)
    y = np.sin(x + i/10.0)
    line, = ax.plot(x, y)
    frames.append([line])  # Iga kaader on Artist-objektide loend

ani = animation.ArtistAnimation(fig, frames, interval=50, blit=True, repeat_delay=1000)

plt.show()

            

              
                Copy
              
            
          

Selgitus:

1. Loome loendi nimega `frames`.
2. Kordame 50 korda ja igal iteratsioonil loome joonise ning lisame selle `frames` loendisse. `frames` iga element on loend, mis sisaldab Artist-objekti (objekte), mida selles kaadris kuvatakse.
3. Loome ArtistAnimation objekti, edastades sellele Figure, kaadrite loendi ja muud parameetrid. `repeat_delay` parameeter määrab viivituse (millisekundites) enne animatsiooni kordamist.

Animatsiooni salvestamine

Matplotlib võimaldab teil oma animatsioone salvestada erinevates formaatides, näiteks GIF, MP4 ja WebM. Vajate sobiva kodeki installimist (nt FFmpeg või Pillow). Kodeerija teisendab üksikud kaadrid lõplikuks videoformaadiks.

            ani.save('sine_wave.mp4', writer='ffmpeg', fps=30)

            

              
                Copy
              
            
          

See kood salvestab animatsiooni MP4-failina, kasutades FFmpeg kirjutajat, 30 kaadrit sekundis.

Kodeerijate installimine

Animatsioonide salvestamiseks peate installima kodeeri. FFmpeg on populaarne valik.

Linuxis (Debian/Ubuntu):

            sudo apt-get update
sudo apt-get install ffmpeg

            

              
                Copy
              
            
          

macOS-is:

            brew install ffmpeg

            

              
                Copy
              
            
          

Windowsis:

Laadige FFmpeg alla ametlikult veebisaidilt (https://ffmpeg.org/download.html) ja lisage `bin` kataloog oma süsteemi PATH keskkonnamuutujasse.

Alternatiivina saate Pillow abil animatsioone GIF-failidena salvestada:

            ani.save('sine_wave.gif', writer='pillow')

            

              
                Copy
              
            
          

Veenduge, et Pillow on installitud:

            pip install pillow

            

              
                Copy
              
            
          

Täiustatud animatsioonitehnikad

Hajusgraafikute animeerimine

Saate individuaalsete andmepunktide liikumise visualiseerimiseks hajusskriine animeerida.

            import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

fig, ax = plt.subplots()
xdata, ydata = [], []
ln, = plt.plot([], [], 'ro', animated=True)

def init():
    ax.set_xlim(0, 10)
    ax.set_ylim(0, 10)
    return ln,

def update(frame):
    xdata.append(frame/10)
    ydata.append(np.sin(frame/10))
    ln.set_data(xdata, ydata)
    return ln,

ani = animation.FuncAnimation(fig, update, frames=np.linspace(0, 100, 100), init_func=init, blit=True)
plt.show()

            

              
                Copy
              
            
          

See kood loob hajusskriini, kus andmepunktid liiguvad mööda siinuslaine.

3D-graafikute animeerimine

Matplotlib toetab ka 3D-graafikute animeerimist, kasutades moodulit mpl_toolkits.mplot3d.

            import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from mpl_toolkits.mplot3d import Axes3D

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

def update(num, data, line):
    line.set_data(data[:2, :num])
    line.set_3d_properties(data[2, :num])
    return line,

# Korrapäraseks reprodutseerimiseks fikseeritud juhuslik olek
np.random.seed(19680801)

data = np.random.rand(3, 50)
line, = ax.plot(data[0, 0:1], data[1, 0:1], data[2, 0:1])

# Telgede atribuutide seadmine
ax.set_xlim3d([0.0, 1.0])
ax.set_xlabel('X')

ax.set_ylim3d([0.0, 1.0])
ax.set_ylabel('Y')

ax.set_zlim3d([0.0, 1.0])
ax.set_zlabel('Z')

ax.set_title('3D Test')

ani = animation.FuncAnimation(fig, update, 50, fargs=(data, line), interval=50, blit=False)

plt.show()

            

              
                Copy
              
            
          

See kood loob lihtsa 3D-joonisgraafiku animatsiooni.

Reaalajas andmete visualiseerimine

Matplotlibi animatsiooni saab kasutada reaalajas andmevoogude visualiseerimiseks. See nõuab andmete pidevat hankimist ja graafiku vastavat värskendamist.

            import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import time

fig, ax = plt.subplots()
xdata, ydata = [], []
ln, = plt.plot([], [], 'r-', animated=True)

def init():
    ax.set_xlim(0, 10)
    ax.set_ylim(-1, 1)
    return ln,

def update(frame):
    # Simulatsiooni andmete lugemist sensorilt (asenda oma tegeliku andmeallikaga)
    xdata.append(time.time() % 10)  # Simuleeri aja jooksul muutuvaid x-väärtusi
    ydata.append(np.sin(xdata[-1])) # Simuleeri y-väärtusi x põhjal

    # Hoia ainult viimased 50 andmepunkti
    xdata_trimmed = xdata[-50:]
    ydata_trimmed = ydata[-50:]

    ln.set_data(xdata_trimmed, ydata_trimmed)
    ax.relim()
    ax.autoscale_view()
    return ln,

ani = animation.FuncAnimation(fig, update, init_func=init, blit=False, interval=20)
plt.show()

            

              
                Copy
              
            
          

See näide simuleerib andmete lugemist sensorilt ja graafiku reaalajas värskendamist. Asendage simuleeritud andmeallikas oma tegeliku andmevooga.

Jõudluse kaalutlused

Animatsioon võib olla arvutuslikult mahukas, eriti keerukate graafikute ja paljude andmepunktide puhul. Siin on mõned näpunäited jõudluse optimeerimiseks:

• Kasutage blit=True: See valik parandab oluliselt jõudlust, joonistades uuesti ainult need osa graafikust, mis on muutunud.
• Minimeerige arvutusi animatsioonifunktsioonis: Tehke võimalikult palju arvutusi väljaspool animatsioonifunktsiooni, et vältida korduvaid arvutusi.
• Vähendage kaadrisagedust: Madalam kaadrisagedus võib vähendada arvutuskoormust. Katsetage erinevaid interval väärtusi, et leida hea tasakaal sujuvuse ja jõudluse vahel.
• Lihtsustage graafikuelemente: Vähendage graafikuelementide (nt jooned, markerid) arvu, et vähendada renderdamisaega.
• Kasutage riistvaralist kiirendust: Veenduge, et teie graafikakaardi draiverid on ajakohased ja et Matplotlib on konfigureeritud kasutama riistvaralist kiirendust, kui see on saadaval.

Rahvusvahelistumise kaalutlused animeeritud visualiseeringute jaoks

Kui loote animatsioone ülemaailmse publiku jaoks, kaaluge järgmisi rahvusvahelistumise aspekte:

• Keel: Kasutage tekstiannotatsioonides selget ja lühikest keelt. Kaaluge animatsioonide pakkumist mitmekeelsete versioonidena.
• Numbrite vorming: Kasutage erinevate lokalite jaoks sobivat numbrite vormingut (nt kümnendkoha eraldajaid, tuhandete eraldajaid). Pythoni `locale` moodul võib selles aidata.
• Kuupäeva ja kellaaja vorming: Sarnaselt vormistage kuupäevi ja kellaaegu vastavalt kasutaja lokalile.
• Värvide taju: Olge teadlik värvide tajumisest erinevate kultuuride vahel ja vältige värvide kasutamist, millel võivad olla negatiivsed konnotatsioonid teatud piirkondades.
• Juurdepääsetavus: Veenduge, et teie animatsioonid oleksid puuetega kasutajatele kättesaadavad. Pakkuge animatsioonidele alternatiivseid tekstikirjeldusi ja kasutage värvipale, mis on värvipimedusega kasutajatele kättesaadavad.
• Andmeühikud: Olge teadlik erinevatest mõõtesüsteemidest (nt meetriline vs. imperiaalne) ja esitage andmed sihtrühmale sobivates ühikutes.

Näiteks finantsandmete kuvamisel peaksid valuutad ja numbriformaadid olema lokaliseeritud. Geograafiliste andmete kuvamisel veenduge, et kaardiprojektsioonid sobiksid huvipakkuva piirkonnaga ja et kohanimed oleksid lokaliseeritud.

Siin on näide, mis kasutab `locale` moodulit numbrite vormindamiseks vastavalt kasutaja lokalile. Märkus: see näide nõuab süsteemis õige lokaliseerimise installimist ja ei ole ilma sellise seadistuseta üldiselt käivitatav.

            import locale
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

# Proovige lokaliseerimist määrata konkreetsele (nt Saksa)
try:
    locale.setlocale(locale.LC_ALL, 'de_DE.UTF-8')
except locale.Error:
    print("Hoiatus: Lokaliseerimist 'de_DE.UTF-8' pole saadaval. Kasutatakse vaikimisi lokaliseerimist.")

fig, ax = plt.subplots()
x = np.linspace(0, 2*np.pi, 100)
line, = ax.plot(x, np.sin(x))
text = ax.text(0.05, 0.95, '', transform=ax.transAxes, ha='left', va='top')

def animate(i):
    line.set_ydata(np.sin(x + i/10.0))
    formatted_number = locale.format_string("%.2f", i * 1234.567, grouping=True)
    text.set_text(f'Väärtus: {formatted_number}')  # f-string selgema vormingu jaoks
    return line, text

ani = animation.FuncAnimation(fig, animate, frames=200, interval=20, blit=True)

plt.show()

            

              
                Copy
              
            
          

Juhtumiuuringud: Näited kogu maailmast

Vaatame mõningaid hüpoteetilisi näiteid selle kohta, kuidas Matplotlibi animatsioone võiks kasutada erinevate piirkondade andmete visualiseerimiseks:

• Metsade hävitamise jälgimine Amazonase vihmametsas (Lõuna-Ameerika): Animatsioon võiks näidata aja jooksul kahanevat metsaala, tõstes esile märkimisväärse kaduga alasid ja visualiseerides metsade hävitamise mõju bioloogilisele mitmekesisusele.
• Õhusaaste tasemete visualiseerimine Aasia suurimates linnades (Aasia): Animatsioon võiks kujutada õhusaasteainete (nt PM2.5) muutumist linnades nagu Peking, Delhi ja Tokyo, illustreerides hooajalist varieeruvust ja saastekontrollimeetmete tõhusust.
• Malaaria leviku modelleerimine Sahara-taguses Aafrikas (Aafrika): Animatsioon võiks simuleerida malaaria levikut, tuginedes sellistele teguritele nagu sademed, temperatuur ja sääskede populatsioon, aidates tuvastada suure riskiga alasid ja teavitada rahvatervise sekkumisi.
• Euroopa riikide majanduskasvu analüüsimine (Euroopa): Animatsioon võiks näidata erinevate Euroopa riikide SKP kasvumäärasid aja jooksul, võrrelda nende tulemuslikkust ja tõsta esile majanduslanguse või kasvu perioode. Visualiseerimist saab ka kujundada andmete esitamiseks kultuuriliselt tundlikul viisil, kasutades värviskeeme ja sümboleid, mis ei põhjusta solvangut üheski konkreetse riigis.
• Põhja-Ameerika metropolipiirkondade liikluse voo simuleerimine (Põhja-Ameerika): Animatsioon võiks visualiseerida reaalajas liikluse voogu linnades nagu New York, Los Angeles ja Toronto, näidates ummikute mustreid ja aidates optimeerida liikluse haldamise strateegiaid.

Kokkuvõte

Matplotlibi animatsioon pakub võimsat tööriista dünaamiliste graafikute loomiseks, mis parandavad andmete visualiseerimist. Ükskõik, kas visualiseerite ajatrende, illustreerite keerulisi suhteid või esitate reaalajas andmeid, animatsioon võib teie publiku mõistmist ja kaasatust oluliselt parandada. Omandades selles blogipostituses käsitletud tehnikad, saate vabastada Matplotlibi animatsiooni täieliku potentsiaali ja luua köitvaid visualiseeringuid, mis äratavad teie andmed ellu.